home *** CD-ROM | disk | FTP | other *** search
/ Champak 146 / (Vol 146) Jan 07 2012.iso / Games / screamin_upstreamin.swf / scripts / DefineSprite_180 / frame_11 / DoAction.as
Text File  |  2012-01-07  |  48KB  |  1,091 lines

  1. var ┬º\x01┬º = 921;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 921)
  6.    {
  7.       set("\x01",eval("\x01") - 394);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 865)
  12.    {
  13.       set("\x01",eval("\x01") - 412);
  14.       continue;
  15.    }
  16.    if(eval("\x01") == 1)
  17.    {
  18.       set("\x01",eval("\x01") + 583);
  19.       break;
  20.    }
  21.    if(eval("\x01") == 393)
  22.    {
  23.       set("\x01",eval("\x01") + 472);
  24.       break;
  25.    }
  26.    if(eval("\x01") == 974)
  27.    {
  28.       set("\x01",eval("\x01") - 513);
  29.       loop1:
  30.       while(true)
  31.       {
  32.          set(┬º┬ºpop(),eval(┬º┬ºpop()) + 817);
  33.          loop2:
  34.          while(true)
  35.          {
  36.             if(eval("\x01") == 334)
  37.             {
  38.                set("\x01",eval("\x01") + 338);
  39.                ┬º┬ºpush(true);
  40.                continue;
  41.             }
  42.             if(eval("\x01") == 267)
  43.             {
  44.                set("\x01",eval("\x01") + 410);
  45.                ┬º┬ºpush(true);
  46.                continue;
  47.             }
  48.             if(eval("\x01") == 672)
  49.             {
  50.                set("\x01",eval("\x01") - 246);
  51.                if(┬º┬ºpop())
  52.                {
  53.                   set("\x01",eval("\x01") + 477);
  54.                }
  55.                continue;
  56.             }
  57.             addr439:
  58.             ┬º┬ºpush(eval("\x01") == 722);
  59.             while(true)
  60.             {
  61.                if(!┬º┬ºpop())
  62.                {
  63.                   if(eval("\x01") == 528)
  64.                   {
  65.                      set("\x01",eval("\x01") + 252);
  66.                      break loop0;
  67.                   }
  68.                   if(eval("\x01") != 265)
  69.                   {
  70.                      if(eval("\x01") == 772)
  71.                      {
  72.                         set("\x01",eval("\x01") - 287);
  73.                         break loop0;
  74.                      }
  75.                      if(eval("\x01") == 910)
  76.                      {
  77.                         set("\x01",eval("\x01") - 154);
  78.                         continue loop2;
  79.                         continue loop2;
  80.                      }
  81.                      if(eval("\x01") != 654)
  82.                      {
  83.                         if(eval("\x01") != 810)
  84.                         {
  85.                            if(eval("\x01") != 858)
  86.                            {
  87.                               if(eval("\x01") != 639)
  88.                               {
  89.                                  if(eval("\x01") == 956)
  90.                                  {
  91.                                     set("\x01",eval("\x01") - 234);
  92.                                     break loop0;
  93.                                  }
  94.                                  if(eval("\x01") == 73)
  95.                                  {
  96.                                     set("\x01",eval("\x01") + 363);
  97.                                     continue loop2;
  98.                                     continue loop2;
  99.                                  }
  100.                                  if(eval("\x01") == 250)
  101.                                  {
  102.                                     set("\x01",eval("\x01") + 17);
  103.                                     continue loop2;
  104.                                  }
  105.                                  if(eval("\x01") == 293)
  106.                                  {
  107.                                     set("\x01",eval("\x01") + 246);
  108.                                     ┬º┬ºpush(true);
  109.                                     continue loop2;
  110.                                  }
  111.                                  if(eval("\x01") == 123)
  112.                                  {
  113.                                     set("\x01",eval("\x01") + 170);
  114.                                     continue loop2;
  115.                                     continue loop2;
  116.                                  }
  117.                                  if(eval("\x01") == 749)
  118.                                  {
  119.                                     set("\x01",eval("\x01") - 484);
  120.                                     break loop0;
  121.                                  }
  122.                               }
  123.                               set("\x01",eval("\x01") - 346);
  124.                               continue loop2;
  125.                               if(eval("\x01") != 632)
  126.                               {
  127.                                  if(eval("\x01") == 158)
  128.                                  {
  129.                                     break loop2;
  130.                                  }
  131.                                  if(eval("\x01") == 726)
  132.                                  {
  133.                                     set("\x01",eval("\x01") - 409);
  134.                                     ┬º┬ºpush(true);
  135.                                     continue loop2;
  136.                                     continue loop2;
  137.                                  }
  138.                                  if(eval("\x01") != 539)
  139.                                  {
  140.                                     if(eval("\x01") == 148)
  141.                                     {
  142.                                        set("\x01",eval("\x01") + 178);
  143.                                        break loop0;
  144.                                     }
  145.                                     if(eval("\x01") == 336)
  146.                                     {
  147.                                        set("\x01",eval("\x01") + 148);
  148.                                        set("\t",24);
  149.                                        continue loop2;
  150.                                     }
  151.                                     if(eval("\x01") != 326)
  152.                                     {
  153.                                        if(eval("\x01") != 677)
  154.                                        {
  155.                                           if(eval("\x01") != 960)
  156.                                           {
  157.                                              if(eval("\x01") == 954)
  158.                                              {
  159.                                                 set("\x01",eval("\x01") - 315);
  160.                                              }
  161.                                              else
  162.                                              {
  163.                                                 if(eval("\x01") == 923)
  164.                                                 {
  165.                                                    set("\x01",eval("\x01") - 98);
  166.                                                    continue loop2;
  167.                                                 }
  168.                                                 if(eval("\x01") == 897)
  169.                                                 {
  170.                                                    set("\x01",eval("\x01") + 57);
  171.                                                    if(┬º┬ºpop())
  172.                                                    {
  173.                                                       set("\x01",eval("\x01") - 315);
  174.                                                    }
  175.                                                    continue loop2;
  176.                                                 }
  177.                                                 if(eval("\x01") == 426)
  178.                                                 {
  179.                                                    set("\x01",eval("\x01") + 477);
  180.                                                    break loop0;
  181.                                                 }
  182.                                                 if(eval("\x01") == 825)
  183.                                                 {
  184.                                                    set("\x01",eval("\x01") - 524);
  185.                                                    ┬º┬ºpush(true);
  186.                                                    continue loop2;
  187.                                                 }
  188.                                                 if(eval("\x01") != 317)
  189.                                                 {
  190.                                                    if(eval("\x01") != 903)
  191.                                                    {
  192.                                                       if(eval("\x01") == 484)
  193.                                                       {
  194.                                                          set("\x01",eval("\x01") + 148);
  195.                                                          if(eval("\t") == 24)
  196.                                                          {
  197.                                                             break loop0;
  198.                                                          }
  199.                                                          continue loop2;
  200.                                                       }
  201.                                                       if(eval("\x01") == 780)
  202.                                                       {
  203.                                                          set("\x01",eval("\x01") - 148);
  204.                                                          continue loop2;
  205.                                                       }
  206.                                                       if(eval("\x01") == 683)
  207.                                                       {
  208.                                                          set("\x01",eval("\x01") + 304);
  209.                                                          ┬º┬ºpush(true);
  210.                                                          continue loop2;
  211.                                                       }
  212.                                                       if(eval("\x01") == 918)
  213.                                                       {
  214.                                                          set("\x01",eval("\x01") - 390);
  215.                                                          if(┬º┬ºpop())
  216.                                                          {
  217.                                                             set("\x01",eval("\x01") + 252);
  218.                                                          }
  219.                                                          continue loop2;
  220.                                                       }
  221.                                                       if(eval("\x01") == 987)
  222.                                                       {
  223.                                                          set("\x01",eval("\x01") - 233);
  224.                                                          if(┬º┬ºpop())
  225.                                                          {
  226.                                                             set("\x01",eval("\x01") - 681);
  227.                                                          }
  228.                                                          continue loop2;
  229.                                                       }
  230.                                                       if(eval("\x01") != 485)
  231.                                                       {
  232.                                                          if(eval("\x01") == 756)
  233.                                                          {
  234.                                                             break loop1;
  235.                                                          }
  236.                                                          if(eval("\x01") != 22)
  237.                                                          {
  238.                                                             if(eval("\x01") != 256)
  239.                                                             {
  240.                                                                if(eval("\x01") != 375)
  241.                                                                {
  242.                                                                   if(eval("\x01") != 301)
  243.                                                                   {
  244.                                                                      if(eval("\x01") != 436)
  245.                                                                      {
  246.                                                                         if(eval("\x01") == 171)
  247.                                                                         {
  248.                                                                            set("\x01",eval("\x01") + 391);
  249.                                                                            loop3:
  250.                                                                            while(true)
  251.                                                                            {
  252.                                                                               set(┬º┬ºpop(),┬º┬ºpop() - 181);
  253.                                                                               if(┬º┬ºpop())
  254.                                                                               {
  255.                                                                                  set("\x01",eval("\x01") + 163);
  256.                                                                               }
  257.                                                                               while(true)
  258.                                                                               {
  259.                                                                                  if(eval("\x01") == 169)
  260.                                                                                  {
  261.                                                                                     set("\x01",eval("\x01") + 497);
  262.                                                                                     ┬º┬ºpush(true);
  263.                                                                                     continue;
  264.                                                                                  }
  265.                                                                                  if(eval("\x01") == 999)
  266.                                                                                  {
  267.                                                                                     set("\x01",eval("\x01") - 317);
  268.                                                                                     continue;
  269.                                                                                  }
  270.                                                                                  if(eval("\x01") == 972)
  271.                                                                                  {
  272.                                                                                     set("\x01",eval("\x01") - 336);
  273.                                                                                     ┬º┬ºpush(true);
  274.                                                                                     continue;
  275.                                                                                  }
  276.                                                                                  if(eval("\x01") == 648)
  277.                                                                                  {
  278.                                                                                     set("\x01",eval("\x01") + 34);
  279.                                                                                     continue;
  280.                                                                                  }
  281.                                                                                  if(eval("\x01") == 331)
  282.                                                                                  {
  283.                                                                                     set("\x01",eval("\x01") + 641);
  284.                                                                                     continue;
  285.                                                                                  }
  286.                                                                                  if(eval("\x01") == 748)
  287.                                                                                  {
  288.                                                                                     set("\x01",eval("\x01") - 184);
  289.                                                                                     continue;
  290.                                                                                  }
  291.                                                                                  if(eval("\x01") == 666)
  292.                                                                                  {
  293.                                                                                     break;
  294.                                                                                  }
  295.                                                                                  if(eval("\x01") != 485)
  296.                                                                                  {
  297.                                                                                     if(eval("\x01") == 113)
  298.                                                                                     {
  299.                                                                                        set("\x01",eval("\x01") + 591);
  300.                                                                                     }
  301.                                                                                     else if(eval("\x01") == 636)
  302.                                                                                     {
  303.                                                                                        set("\x01",eval("\x01") - 195);
  304.                                                                                        if(┬º┬ºpop())
  305.                                                                                        {
  306.                                                                                           set("\x01",eval("\x01") - 328);
  307.                                                                                        }
  308.                                                                                     }
  309.                                                                                     else
  310.                                                                                     {
  311.                                                                                        if(eval("\x01") == 564)
  312.                                                                                        {
  313.                                                                                           set("\x01",eval("\x01") + 347);
  314.                                                                                           stop();
  315.                                                                                           break loop0;
  316.                                                                                        }
  317.                                                                                        if(eval("\x01") == 441)
  318.                                                                                        {
  319.                                                                                           set("\x01",eval("\x01") - 328);
  320.                                                                                           break loop0;
  321.                                                                                        }
  322.                                                                                        if(eval("\x01") == 545)
  323.                                                                                        {
  324.                                                                                           set("\x01",eval("\x01") - 165);
  325.                                                                                           if(┬º┬ºpop())
  326.                                                                                           {
  327.                                                                                              set("\x01",eval("\x01") + 368);
  328.                                                                                           }
  329.                                                                                        }
  330.                                                                                        else if(eval("\x01") == 682)
  331.                                                                                        {
  332.                                                                                           set("\x01",eval("\x01") - 461);
  333.                                                                                           ┬º┬ºpush(true);
  334.                                                                                        }
  335.                                                                                        else if(eval("\x01") == 470)
  336.                                                                                        {
  337.                                                                                           set("\x01",eval("\x01") + 502);
  338.                                                                                        }
  339.                                                                                        else
  340.                                                                                        {
  341.                                                                                           if(eval("\x01") == 380)
  342.                                                                                           {
  343.                                                                                              break loop3;
  344.                                                                                           }
  345.                                                                                           if(eval("\x01") == 226)
  346.                                                                                           {
  347.                                                                                              set("\x01",eval("\x01") + 244);
  348.                                                                                              break loop0;
  349.                                                                                           }
  350.                                                                                           if(eval("\x01") == 995)
  351.                                                                                           {
  352.                                                                                              set("\x01",eval("\x01") - 291);
  353.                                                                                           }
  354.                                                                                           else if(eval("\x01") == 221)
  355.                                                                                           {
  356.                                                                                              set("\x01",eval("\x01") + 5);
  357.                                                                                              if(┬º┬ºpop())
  358.                                                                                              {
  359.                                                                                                 set("\x01",eval("\x01") + 244);
  360.                                                                                              }
  361.                                                                                           }
  362.                                                                                           else if(eval("\x01") == 704)
  363.                                                                                           {
  364.                                                                                              set("\x01",eval("\x01") - 159);
  365.                                                                                              ┬º┬ºpush(true);
  366.                                                                                           }
  367.                                                                                           else
  368.                                                                                           {
  369.                                                                                              if(eval("\x01") != 983)
  370.                                                                                              {
  371.                                                                                                 if(eval("\x01") == 911)
  372.                                                                                                 {
  373.                                                                                                    set("\x01",eval("\x01") - 911);
  374.                                                                                                    break loop0;
  375.                                                                                                 }
  376.                                                                                                 break loop0;
  377.                                                                                              }
  378.                                                                                              set("\x01",eval("\x01") - 419);
  379.                                                                                           }
  380.                                                                                        }
  381.                                                                                     }
  382.                                                                                     continue;
  383.                                                                                  }
  384.                                                                                  ┬º┬ºpush("\x01");
  385.                                                                                  ┬º┬ºpush(eval("\x01") + 163);
  386.                                                                               }
  387.                                                                            }
  388.                                                                            set("\x01",eval("\x01") + 368);
  389.                                                                            stop();
  390.                                                                            ┬º┬ºpush(getTimer());
  391.                                                                            break loop0;
  392.                                                                         }
  393.                                                                         if(eval("\x01") == 975)
  394.                                                                         {
  395.                                                                            set("\x01",eval("\x01") - 953);
  396.                                                                            ┬º┬ºpush(true);
  397.                                                                            continue loop2;
  398.                                                                         }
  399.                                                                         if(eval("\x01") == 579)
  400.                                                                         {
  401.                                                                            set("\x01",eval("\x01") - 143);
  402.                                                                            continue loop2;
  403.                                                                         }
  404.                                                                         if(eval("\x01") != 562)
  405.                                                                         {
  406.                                                                            if(eval("\x01") == 560)
  407.                                                                            {
  408.                                                                               set("\x01",eval("\x01") - 560);
  409.                                                                               break loop0;
  410.                                                                            }
  411.                                                                            if(eval("\x01") == 754)
  412.                                                                            {
  413.                                                                               set("\x01",eval("\x01") - 681);
  414.                                                                               ┬º┬ºpush(┬º┬ºpop()(┬º┬ºpop()));
  415.                                                                               break loop0;
  416.                                                                            }
  417.                                                                         }
  418.                                                                      }
  419.                                                                      set("\x01",eval("\x01") - 61);
  420.                                                                      ┬º┬ºpush(true);
  421.                                                                      continue loop2;
  422.                                                                   }
  423.                                                                   set("\x01",eval("\x01") - 130);
  424.                                                                   if(┬º┬ºpop())
  425.                                                                   {
  426.                                                                      set("\x01",eval("\x01") + 391);
  427.                                                                   }
  428.                                                                   continue loop2;
  429.                                                                }
  430.                                                                set("\x01",eval("\x01") + 374);
  431.                                                                if(┬º┬ºpop())
  432.                                                                {
  433.                                                                   set("\x01",eval("\x01") - 484);
  434.                                                                }
  435.                                                                continue loop2;
  436.                                                             }
  437.                                                             set("\x01",eval("\x01") + 602);
  438.                                                             continue loop2;
  439.                                                             set("\x01",eval("\x01") + 194);
  440.                                                          }
  441.                                                          set("\x01",eval("\x01") + 934);
  442.                                                          if(┬º┬ºpop())
  443.                                                          {
  444.                                                             set("\x01",eval("\x01") - 234);
  445.                                                          }
  446.                                                       }
  447.                                                    }
  448.                                                    set("\x01",eval("\x01") - 220);
  449.                                                    continue loop2;
  450.                                                    continue loop2;
  451.                                                    set("\x01",eval("\x01") + 490);
  452.                                                    continue loop2;
  453.                                                    continue loop2;
  454.                                                    break loop0;
  455.                                                 }
  456.                                                 set("\x01",eval("\x01") + 455);
  457.                                                 while(true)
  458.                                                 {
  459.                                                    if(┬º┬ºpop())
  460.                                                    {
  461.                                                       set("\x01",eval("\x01") - 287);
  462.                                                    }
  463.                                                    continue loop2;
  464.                                                 }
  465.                                              }
  466.                                              set(┬º┬ºpop(),┬º┬ºpop());
  467.                                           }
  468.                                           set("\x01",eval("\x01") - 277);
  469.                                           continue loop2;
  470.                                        }
  471.                                        set("\x01",eval("\x01") - 341);
  472.                                        if(┬º┬ºpop())
  473.                                        {
  474.                                           set("\x01",eval("\x01") + 474);
  475.                                        }
  476.                                     }
  477.                                     set("\x01",eval("\x01") - 59);
  478.                                  }
  479.                                  set("\x01",eval("\x01") - 391);
  480.                                  if(┬º┬ºpop())
  481.                                  {
  482.                                     set("\x01",eval("\x01") + 178);
  483.                                  }
  484.                               }
  485.                               set("\x01",eval("\x01") + 265);
  486.                            }
  487.                            set("\x01",eval("\x01") + 60);
  488.                            ┬º┬ºpush(true);
  489.                            continue loop2;
  490.                         }
  491.                         set("\x01",eval("\x01") + 15);
  492.                         continue loop2;
  493.                         ┬º┬ºpush(true);
  494.                      }
  495.                      set("\x01",eval("\x01") + 72);
  496.                   }
  497.                   set("\x01",eval("\x01") + 461);
  498.                   continue loop2;
  499.                }
  500.                set("\x01",eval("\x01") + 136);
  501.                continue loop2;
  502.             }
  503.          }
  504.       }
  505.       set("\x01",eval("\x01") - 196);
  506.       pRoot.gotoAndPlay("finished");
  507.       break;
  508.    }
  509.    if(eval("\x01") == 44)
  510.    {
  511.       set("\x01",eval("\x01") + 611);
  512.       continue;
  513.    }
  514.    if(eval("\x01") == 3)
  515.    {
  516.       set("\x01",eval("\x01") + 342);
  517.       if(┬º┬ºpop())
  518.       {
  519.          set("\x01",eval("\x01") - 225);
  520.       }
  521.       continue;
  522.    }
  523.    if(eval("\x01") == 584)
  524.    {
  525.       set("\x01",eval("\x01") + 127);
  526.       continue;
  527.    }
  528.    if(eval("\x01") == 139)
  529.    {
  530.       set("\x01",eval("\x01") + 688);
  531.       if(┬º┬ºpop())
  532.       {
  533.          set("\x01",eval("\x01") - 309);
  534.       }
  535.       continue;
  536.    }
  537.    if(eval("\x01") == 680)
  538.    {
  539.       set("\x01",eval("\x01") - 372);
  540.       continue;
  541.    }
  542.    if(eval("\x01") == 389)
  543.    {
  544.       set("\x01",eval("\x01") - 15);
  545.       break;
  546.    }
  547.    if(eval("\x01") == 821)
  548.    {
  549.       set("\x01",eval("\x01") - 432);
  550.       if(┬º┬ºpop())
  551.       {
  552.          set("\x01",eval("\x01") - 15);
  553.       }
  554.       continue;
  555.    }
  556.    if(eval("\x01") == 120)
  557.    {
  558.       set("\x01",eval("\x01") + 796);
  559.       continue;
  560.    }
  561.    if(eval("\x01") == 243)
  562.    {
  563.       set("\x01",eval("\x01") - 242);
  564.       if(┬º┬ºpop())
  565.       {
  566.          set("\x01",eval("\x01") + 583);
  567.       }
  568.       continue;
  569.    }
  570.    if(eval("\x01") == 916)
  571.    {
  572.       set("\x01",eval("\x01") - 616);
  573.       ┬º┬ºpush(true);
  574.       continue;
  575.    }
  576.    if(eval("\x01") == 104)
  577.    {
  578.       set("\x01",eval("\x01") + 349);
  579.       continue;
  580.    }
  581.    if(eval("\x01") == 453)
  582.    {
  583.       set("\x01",eval("\x01") - 440);
  584.       ┬º┬ºpush(true);
  585.       continue;
  586.    }
  587.    if(eval("\x01") == 13)
  588.    {
  589.       set("\x01",eval("\x01") + 357);
  590.       if(┬º┬ºpop())
  591.       {
  592.          set("\x01",eval("\x01") + 168);
  593.       }
  594.       continue;
  595.    }
  596.    if(eval("\x01") == 308)
  597.    {
  598.       set("\x01",eval("\x01") - 285);
  599.       ┬º┬ºpush(true);
  600.       continue;
  601.    }
  602.    if(eval("\x01") == 267)
  603.    {
  604.       set("\x01",eval("\x01") + 388);
  605.       continue;
  606.    }
  607.    if(eval("\x01") == 369)
  608.    {
  609.       set("\x01",eval("\x01") + 24);
  610.       if(┬º┬ºpop())
  611.       {
  612.          set("\x01",eval("\x01") + 472);
  613.       }
  614.       continue;
  615.    }
  616.    if(eval("\x01") == 345)
  617.    {
  618.       set("\x01",eval("\x01") - 225);
  619.       prevFrame();
  620.       break;
  621.    }
  622.    if(eval("\x01") == 655)
  623.    {
  624.       set("\x01",eval("\x01") - 516);
  625.       ┬º┬ºpush(true);
  626.       continue;
  627.    }
  628.    if(eval("\x01") == 23)
  629.    {
  630.       set("\x01",eval("\x01") + 450);
  631.       if(┬º┬ºpop())
  632.       {
  633.          set("\x01",eval("\x01") - 206);
  634.       }
  635.       continue;
  636.    }
  637.    if(eval("\x01") == 527)
  638.    {
  639.       set("\x01",eval("\x01") - 332);
  640.       if(┬º┬ºpop())
  641.       {
  642.          set("\x01",eval("\x01") + 537);
  643.       }
  644.       continue;
  645.    }
  646.    if(eval("\x01") == 518)
  647.    {
  648.       set("\x01",eval("\x01") - 95);
  649.       continue;
  650.    }
  651.    if(eval("\x01") == 195)
  652.    {
  653.       set("\x01",eval("\x01") + 537);
  654.       break;
  655.    }
  656.    if(eval("\x01") == 732)
  657.    {
  658.       set("\x01",eval("\x01") - 424);
  659.       continue;
  660.    }
  661.    if(eval("\x01") == 374)
  662.    {
  663.       set("\x01",eval("\x01") + 3);
  664.       continue;
  665.    }
  666.    if(eval("\x01") == 148)
  667.    {
  668.       set("\x01",eval("\x01") - 145);
  669.       ┬º┬ºpush(true);
  670.       continue;
  671.    }
  672.    if(eval("\x01") == 570)
  673.    {
  674.       set("\x01",eval("\x01") - 446);
  675.       continue;
  676.    }
  677.    if(eval("\x01") != 473)
  678.    {
  679.       if(eval("\x01") == 124)
  680.       {
  681.          set("\x01",eval("\x01") + 245);
  682.          ┬º┬ºpush(true);
  683.       }
  684.       else
  685.       {
  686.          if(eval("\x01") == 827)
  687.          {
  688.             set("\x01",eval("\x01") - 309);
  689.             break;
  690.          }
  691.          if(eval("\x01") == 686)
  692.          {
  693.             set("\x01",eval("\x01") + 72);
  694.             stop();
  695.             break;
  696.          }
  697.          if(eval("\x01") == 370)
  698.          {
  699.             set("\x01",eval("\x01") + 168);
  700.             break;
  701.          }
  702.          if(eval("\x01") == 407)
  703.          {
  704.             set("\x01",eval("\x01") - 30);
  705.          }
  706.          else if(eval("\x01") == 43)
  707.          {
  708.             set("\x01",eval("\x01") + 380);
  709.          }
  710.          else if(eval("\x01") == 172)
  711.          {
  712.             set("\x01",eval("\x01") + 744);
  713.          }
  714.          else if(eval("\x01") == 423)
  715.          {
  716.             set("\x01",eval("\x01") - 180);
  717.             ┬º┬ºpush(true);
  718.          }
  719.          else if(eval("\x01") == 260)
  720.          {
  721.             set("\x01",eval("\x01") + 451);
  722.          }
  723.          else if(eval("\x01") == 733)
  724.          {
  725.             set("\x01",eval("\x01") - 47);
  726.          }
  727.          else if(eval("\x01") == 461)
  728.          {
  729.             set("\x01",eval("\x01") - 337);
  730.          }
  731.          else if(eval("\x01") == 711)
  732.          {
  733.             set("\x01",eval("\x01") + 110);
  734.             ┬º┬ºpush(true);
  735.          }
  736.          else if(eval("\x01") == 377)
  737.          {
  738.             set("\x01",eval("\x01") + 454);
  739.             ┬º┬ºpush(true);
  740.          }
  741.          else if(eval("\x01") == 538)
  742.          {
  743.             set("\x01",eval("\x01") + 148);
  744.          }
  745.          else if(eval("\x01") == 300)
  746.          {
  747.             set("\x01",eval("\x01") + 674);
  748.             if(┬º┬ºpop())
  749.             {
  750.                set("\x01",eval("\x01") - 513);
  751.             }
  752.          }
  753.          else if(eval("\x01") == 831)
  754.          {
  755.             set("\x01",eval("\x01") - 654);
  756.             if(┬º┬ºpop())
  757.             {
  758.                set("\x01",eval("\x01") + 738);
  759.             }
  760.          }
  761.          else
  762.          {
  763.             if(eval("\x01") == 758)
  764.             {
  765.                set("\x01",eval("\x01") - 758);
  766.                break;
  767.             }
  768.             if(eval("\x01") == 177)
  769.             {
  770.                set("\x01",eval("\x01") + 738);
  771.                break;
  772.             }
  773.             if(eval("\x01") == 915)
  774.             {
  775.                set("\x01",eval("\x01") - 767);
  776.             }
  777.             else
  778.             {
  779.                if(eval("\x01") != 984)
  780.                {
  781.                   break;
  782.                }
  783.                set("\x01",eval("\x01") - 836);
  784.             }
  785.          }
  786.       }
  787.       continue;
  788.    }
  789.    set("\x01",eval("\x01") - 206);
  790.    while(true)
  791.    {
  792.       if(eval(┬º┬ºpop()) == 320)
  793.       {
  794.          set("\x01",eval("\x01") + 323);
  795.          if(┬º┬ºpop())
  796.          {
  797.             set("\x01",eval("\x01") - 585);
  798.          }
  799.          continue;
  800.       }
  801.       if(eval("\x01") == 342)
  802.       {
  803.          set("\x01",eval("\x01") + 542);
  804.          continue;
  805.       }
  806.       if(eval("\x01") == 884)
  807.       {
  808.          set("\x01",eval("\x01") - 6);
  809.          ┬º┬ºpush(true);
  810.          continue;
  811.       }
  812.       if(eval("\x01") == 328)
  813.       {
  814.          set("\x01",eval("\x01") + 300);
  815.          duplicateMovieClip(┬º┬ºpop(),┬º┬ºpop(),┬º┬ºpop());
  816.          break loop0;
  817.       }
  818.       if(eval("\x01") == 629)
  819.       {
  820.          set("\x01",eval("\x01") - 217);
  821.          continue;
  822.       }
  823.       if(eval("\x01") == 429)
  824.       {
  825.          set("\x01",eval("\x01") + 109);
  826.          break loop0;
  827.       }
  828.       if(eval("\x01") == 72)
  829.       {
  830.          set("\x01",eval("\x01") + 822);
  831.          if(┬º┬ºpop())
  832.          {
  833.             set("\x01",eval("\x01") - 704);
  834.          }
  835.          continue;
  836.       }
  837.       if(eval("\x01") == 971)
  838.       {
  839.          set("\x01",eval("\x01") - 550);
  840.          continue;
  841.       }
  842.       if(eval("\x01") == 722)
  843.       {
  844.          set("\x01",eval("\x01") - 650);
  845.          ┬º┬ºpush(true);
  846.          continue;
  847.       }
  848.       if(eval("\x01") == 894)
  849.       {
  850.          set("\x01",eval("\x01") - 704);
  851.          ┬º┬ºpush(ord({}));
  852.          break loop0;
  853.       }
  854.       if(eval("\x01") == 407)
  855.       {
  856.          set("\x01",eval("\x01") - 13);
  857.          ┬º┬ºpush(true);
  858.          continue;
  859.       }
  860.       if(eval("\x01") == 973)
  861.       {
  862.          set("\x01",eval("\x01") - 561);
  863.          continue;
  864.       }
  865.       if(eval("\x01") == 878)
  866.       {
  867.          set("\x01",eval("\x01") - 449);
  868.          if(┬º┬ºpop())
  869.          {
  870.             set("\x01",eval("\x01") + 109);
  871.          }
  872.          continue;
  873.       }
  874.       if(eval("\x01") == 685)
  875.       {
  876.          set("\x01",eval("\x01") + 15);
  877.          break loop0;
  878.       }
  879.       if(eval("\x01") == 190)
  880.       {
  881.          set("\x01",eval("\x01") + 231);
  882.          continue;
  883.       }
  884.       if(eval("\x01") == 730)
  885.       {
  886.          set("\x01",eval("\x01") - 8);
  887.          continue;
  888.       }
  889.       if(eval("\x01") == 628)
  890.       {
  891.          set("\x01",eval("\x01") - 227);
  892.          continue;
  893.       }
  894.       if(eval("\x01") == 421)
  895.       {
  896.          set("\x01",eval("\x01") + 553);
  897.          ┬º┬ºpush(true);
  898.          continue;
  899.       }
  900.       if(eval("\x01") == 107)
  901.       {
  902.          set("\x01",eval("\x01") + 777);
  903.          continue;
  904.       }
  905.       if(eval("\x01") == 312)
  906.       {
  907.          set("\x01",eval("\x01") + 548);
  908.          continue;
  909.       }
  910.       if(eval("\x01") == 444)
  911.       {
  912.          set("\x01",eval("\x01") + 529);
  913.          ┬º┬ºgoto(addr439);
  914.       }
  915.       else
  916.       {
  917.          if(eval("\x01") == 834)
  918.          {
  919.             set("\x01",eval("\x01") - 492);
  920.             break loop0;
  921.          }
  922.          if(eval("\x01") == 13)
  923.          {
  924.             set("\x01",eval("\x01") + 594);
  925.             ┬º┬ºpush(true);
  926.             continue;
  927.          }
  928.          if(eval("\x01") == 963)
  929.          {
  930.             set("\x01",eval("\x01") - 656);
  931.             eval("∩┐╜a∩┐╜∩┐╜")[">∩┐╜∩┐╜∩┐╜"] = eval("∩┐╜Hc∩┐╜∩┐╜5M")[";i"] / eval("∩┐╜Hc∩┐╜∩┐╜5M")["\x034∩┐╜"] * 100;
  932.             break loop0;
  933.          }
  934.          if(eval("\x01") == 109)
  935.          {
  936.             set("\x01",eval("\x01") + 613);
  937.             continue;
  938.          }
  939.          if(eval("\x01") == 930)
  940.          {
  941.             set("\x01",eval("\x01") - 237);
  942.             continue;
  943.          }
  944.          if(eval("\x01") == 345)
  945.          {
  946.             set("\x01",eval("\x01") + 489);
  947.             if(┬º┬ºpop())
  948.             {
  949.                set("\x01",eval("\x01") - 492);
  950.             }
  951.             continue;
  952.          }
  953.          if(eval("\x01") == 700)
  954.          {
  955.             set("\x01",eval("\x01") - 293);
  956.             continue;
  957.          }
  958.          if(eval("\x01") == 401)
  959.          {
  960.             set("\x01",eval("\x01") + 48);
  961.             ┬º┬ºpush(true);
  962.             continue;
  963.          }
  964.          if(eval("\x01") == 875)
  965.          {
  966.             set("\x01",eval("\x01") - 468);
  967.             continue;
  968.          }
  969.          if(eval("\x01") != 643)
  970.          {
  971.             if(eval("\x01") == 59)
  972.             {
  973.                set("\x01",eval("\x01") + 634);
  974.             }
  975.             else if(eval("\x01") == 987)
  976.             {
  977.                set("\x01",eval("\x01") - 586);
  978.             }
  979.             else if(eval("\x01") == 532)
  980.             {
  981.                set("\x01",eval("\x01") - 12);
  982.                if(┬º┬ºpop())
  983.                {
  984.                   set("\x01",eval("\x01") + 282);
  985.                }
  986.             }
  987.             else if(eval("\x01") == 974)
  988.             {
  989.                set("\x01",eval("\x01") - 646);
  990.                if(┬º┬ºpop())
  991.                {
  992.                   set("\x01",eval("\x01") + 300);
  993.                }
  994.             }
  995.             else if(eval("\x01") == 394)
  996.             {
  997.                set("\x01",eval("\x01") + 50);
  998.                if(┬º┬ºpop())
  999.                {
  1000.                   set("\x01",eval("\x01") + 529);
  1001.                }
  1002.             }
  1003.             else
  1004.             {
  1005.                if(eval("\x01") == 307)
  1006.                {
  1007.                   set("\x01",eval("\x01") - 307);
  1008.                   break loop0;
  1009.                }
  1010.                if(eval("\x01") == 822)
  1011.                {
  1012.                   set("\x01",eval("\x01") - 713);
  1013.                   set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  1014.                   break loop0;
  1015.                }
  1016.                if(eval("\x01") == 209)
  1017.                {
  1018.                   set("\x01",eval("\x01") - 150);
  1019.                   break loop0;
  1020.                }
  1021.                if(eval("\x01") == 607)
  1022.                {
  1023.                   set("\x01",eval("\x01") + 215);
  1024.                   if(┬º┬ºpop())
  1025.                   {
  1026.                      set("\x01",eval("\x01") - 713);
  1027.                   }
  1028.                }
  1029.                else if(eval("\x01") == 449)
  1030.                {
  1031.                   set("\x01",eval("\x01") - 240);
  1032.                   if(┬º┬ºpop())
  1033.                   {
  1034.                      set("\x01",eval("\x01") - 150);
  1035.                   }
  1036.                }
  1037.                else if(eval("\x01") == 412)
  1038.                {
  1039.                   set("\x01",eval("\x01") - 67);
  1040.                   ┬º┬ºpush(true);
  1041.                }
  1042.                else if(eval("\x01") == 999)
  1043.                {
  1044.                   set("\x01",eval("\x01") - 314);
  1045.                   if(┬º┬ºpop())
  1046.                   {
  1047.                      set("\x01",eval("\x01") + 15);
  1048.                   }
  1049.                }
  1050.                else if(eval("\x01") == 266)
  1051.                {
  1052.                   set("\x01",eval("\x01") - 253);
  1053.                }
  1054.                else if(eval("\x01") == 18)
  1055.                {
  1056.                   set("\x01",eval("\x01") + 750);
  1057.                }
  1058.                else if(eval("\x01") == 58)
  1059.                {
  1060.                   set("\x01",eval("\x01") - 45);
  1061.                }
  1062.                else
  1063.                {
  1064.                   if(eval("\x01") == 520)
  1065.                   {
  1066.                      set("\x01",eval("\x01") + 282);
  1067.                      break loop0;
  1068.                   }
  1069.                   if(eval("\x01") == 768)
  1070.                   {
  1071.                      set("\x01",eval("\x01") - 448);
  1072.                      ┬º┬ºpush(true);
  1073.                   }
  1074.                   else
  1075.                   {
  1076.                      if(eval("\x01") != 802)
  1077.                      {
  1078.                         break loop0;
  1079.                      }
  1080.                      set("\x01",eval("\x01") - 34);
  1081.                   }
  1082.                }
  1083.             }
  1084.             continue;
  1085.          }
  1086.          set("\x01",eval("\x01") - 585);
  1087.       }
  1088.    }
  1089.    ┬º┬ºgoto(addr867);
  1090. }
  1091.